/*
 ** Authored by Timothy Gerard Endres
 ** <mailto:time@gjt.org>  <http://www.trustice.com>
 ** 
 ** This work has been placed into the public domain.
 ** You may use this work in any way and for any purpose you wish.
 **
 ** THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
 ** NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR
 ** OF THIS SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY
 ** CONSEQUENCE RESULTING FROM THE USE, MODIFICATION, OR
 ** REDISTRIBUTION OF THIS SOFTWARE. 
 ** 
 */
package be.djdb.externstuff.tuned;

import java.io.*;
import javax.activation.*;
/**
 * The TarArchive class implements the concept of a tar archive. A tar archive
 * is a series of entries, each of which represents a file system object. Each
 * entry in the archive consists of a header record. Directory entries consist
 * only of the header record, and are followed by entries for the directory's
 * contents. File entries consist of a header record followed by the number of
 * records needed to contain the file's contents. All entries are written on
 * record boundaries. Records are 512 bytes long.
 * TarArchives are instantiated in either read or write mode, based upon whether
 * they are instantiated with an InputStream or an OutputStream. Once
 * instantiated TarArchives read/write mode can not be changed.
 * There is currently no support for random access to tar archives. However, it
 * seems that subclassing TarArchive, and using the
 * TarBuffer.getCurrentRecordNum() and TarBuffer.getCurrentBlockNum() methods,
 * this would be rather trial.
 * 
 * @version $Revision: 1.15 $
 * @author Timothy Gerard Endres, <time@gjt.org>
 * @see TarBuffer
 * @see TarHeader
 * @see TarEntry
 */
public class TarArchive extends Object {
	protected boolean verbose;
	private static final boolean DEBUG = false;
	protected boolean keepOldFiles;
	protected boolean asciiTranslate;
	protected int userId;
	protected String userName;
	protected int groupId;
	protected String groupName;
	protected String rootPath;
	protected String tempPath;
	protected String pathPrefix;
	protected int recordSize;
	protected byte[] recordBuf;
	protected TarInputStream tarIn;
	protected TarOutputStream tarOut;
	/*
	protected TarProgressDisplay progressDisplay;
	 */
	/**
	 * The InputStream based constructors create a TarArchive for the purposes
	 * of e'x'tracting or lis't'ing a tar archive. Thus, use these constructors
	 * when you wish to extract files from or list the contents of an existing
	 * tar archive.
	 */
	public TarArchive(InputStream inStream) {
		this(inStream, TarBuffer.DEFAULT_BLKSIZE);
	}
	public TarArchive(InputStream inStream, int blockSize) {
		this(inStream, blockSize, TarBuffer.DEFAULT_RCDSIZE);
	}
	public TarArchive(InputStream inStream, int blockSize, int recordSize) {
		this.tarIn = new TarInputStream(inStream, blockSize, recordSize);
		this.initialize(recordSize);
	}
	/**
	 * The OutputStream based constructors create a TarArchive for the purposes
	 * of 'c'reating a tar archive. Thus, use these constructors when you wish
	 * to create a new tar archive and write files into it.
	 */
	public TarArchive(OutputStream outStream) {
		this(outStream, TarBuffer.DEFAULT_BLKSIZE);
	}
	public TarArchive(OutputStream outStream, int blockSize) {
		this(outStream, blockSize, TarBuffer.DEFAULT_RCDSIZE);
	}
	public TarArchive(OutputStream outStream, int blockSize, int recordSize) {
		this.tarOut = new TarOutputStream(outStream);
		this.initialize(recordSize);
	}
	/**
	 * Common constructor initialization code.
	 */
	private void initialize(int recordSize) {
		this.rootPath = null;
		this.pathPrefix = null;
		this.tempPath = System.getProperty("user.dir");
		this.userId = 0;
		this.userName = "";
		this.groupId = 0;
		this.groupName = "";
		this.verbose = false;
		this.keepOldFiles = false;
		/*//TODO
		this.progressDisplay = null;
		 */
		this.recordBuf = new byte[this.getRecordSize()];
	}
	/**
	 * Returns the verbosity setting.
	 * @return The current verbosity setting.
	 */
	public boolean isVerbose() {
		return this.verbose;
	}
	/**
	 * Set the verbosity flag.
	 * @param verbose         The new verbosity setting.
	 */
	public void setVerbose(boolean verbose) {
		this.verbose = verbose;
	}
	/**
	 * Set the current progress display interface. This allows the programmer to
	 * use a custom class to display the progress of the archive's processing.
	 * @param display         The new progress display interface.
	 * @see TarProgressDisplay
	 */
	/*//TODO
	public void setTarProgressDisplay(TarProgressDisplay display) {
		this.progressDisplay = display;
	}
	*/
	/**
	 * Set the flag that determines whether existing files are kept, or
	 * overwritten during extraction.
	 * @param keepOldFiles   If true, do not overwrite existing files.
	 */
	public void setKeepOldFiles(boolean keepOldFiles) {
		this.keepOldFiles = keepOldFiles;
	}
	/**
	 * Set the ascii file translation flag. If ascii file translatio is true, then the MIME file type will be consulted to determine if the file is of
	 * type 'text/*'. If the MIME type is not found, then the TransFileTyper is consulted if it is not null. If either of these two checks indicates the
	 * file is an ascii text file, it will be translated. The translation converts the local operating system's concept of line ends into the UNIX
	 * line end, '\n', which is the defacto standard for a TAR archive. This makes text files compatible with UNIX, and since most tar implementations
	 * for other platforms, compatible with most other platforms.
	 * @param asciiTranslate  If true, translate ascii text files.
	 */
	public void setAsciiTranslation(boolean asciiTranslate) {
		this.asciiTranslate = asciiTranslate;
	}
	/**
	 * Set user and group information that will be used to fill in the tar archive's entry headers. Since Java currently provides no means of
	 * determining a user name, user id, group name, or group id for a given File, TarArchive allows the programmer to specify values to be used in
	 * their place.
	 * @param userId           The user Id to use in the headers.
	 * @param userName         The user name to use in the headers.
	 * @param groupId          The group id to use in the headers.
	 * @param groupName        The group name to use in the headers.
	 */
	public void setUserInfo(int userId, String userName, int groupId,String groupName) {
		this.userId = userId;
		this.userName = userName;
		this.groupId = groupId;
		this.groupName = groupName;
	}
	/**
	 * Get the user id being used for archive entry headers.
	 * @return The current user id.
	 */
	public int getUserId() {
		return this.userId;
	}
	/**
	 * Get the user name being used for archive entry headers.
	 * @return The current user name.
	 */
	public String getUserName() {
		return this.userName;
	}
	/**
	 * Get the group id being used for archive entry headers.
	 * @return The current group id.
	 */
	public int getGroupId() {
		return this.groupId;
	}
	/**
	 * Get the group name being used for archive entry headers.
	 * @return The current group name.
	 */
	public String getGroupName() {
		return this.groupName;
	}
	/**
	 * Get the current temporary directory path. Because Java's File did not support temporary files until version 1.2, TarArchive manages its own
	 * concept of the temporary directory. The temporary directory defaults to the 'user.dir' System property.
	 * @return The current temporary directory path.
	 */
	public String getTempDirectory() {
		return this.tempPath;
	}
	/**
	 * Set the current temporary directory path.
	 * @param path       The new temporary directory path.
	 */
	public void setTempDirectory(String path) {
		this.tempPath = path;
	}
	/**
	 * Get the archive's record size. Because of its history, tar supports the concept of buffered IO consisting of BLOCKS of RECORDS. This allowed tar
	 * to match the IO characteristics of the physical device being used. Of course, in the Java world, this makes no sense, WITH ONE EXCEPTION -
	 * archives are expected to be propertly "blocked". Thus, all of the horrible TarBuffer support boils down to simply getting the "boundaries"
	 * correct.
	 * @return The record size this archive is using.
	 */
	public int getRecordSize() {
		if (this.tarIn != null) {
			return this.tarIn.getRecordSize();
		} else if (this.tarOut != null) {
			return this.tarOut.getRecordSize();
		}
		return TarBuffer.DEFAULT_RCDSIZE;
	}
	/**
	 * Get a path for a temporary file for a given File. The temporary file is NOT created. The algorithm attempts to handle filename collisions so that the name is unique.
	 * @return The temporary file's path.
	 */
	private String getTempFilePath(File eFile) {
		String pathStr = this.tempPath + File.separator + eFile.getName()+ ".tmp";
		for (int i = 1; i < 5; ++i) {
			File f = new File(pathStr);
			if (!f.exists())
				break;
			pathStr = this.tempPath + File.separator + eFile.getName() + "-"+ i + ".tmp";
		}
		return pathStr;
	}
	/**
	 * Close the archive. This simply calls the underlying tar stream's close() method.
	 */
	public void closeArchive() throws IOException {
		if (this.tarIn != null) {
			this.tarIn.close();
		} else if (this.tarOut != null) {
			this.tarOut.close();
		}
	}
	/**
	 * Perform the "list" command and list the contents of the archive. NOTE That this method uses the progress display to actually list the conents.
	 * If the progress display is not set, nothing will be listed!
	 */
	public void listContents() throws IOException, InvalidHeaderException {
		for (;;) {
			TarEntry entry = this.tarIn.getNextEntry();
			if (entry == null) {
				if (DEBUG) {System.err.println("READ EOF RECORD");}
				break;
			}
			/*//TODO
			if (this.progressDisplay != null)
				this.progressDisplay.showTarProgressMessage(entry.getName());
			*/
		}
	}
	/**
	 * Perform the "extract" command and extract the contents of the archive.
	 * @param destDir        The destination directory into which to extract.
	 */
	public void extractContents(File destDir) throws IOException,InvalidHeaderException {
		for (;;) {
			TarEntry entry = this.tarIn.getNextEntry();
			if (entry == null) {
				if (DEBUG){System.err.println("READ EOF RECORD");}
				break;
			}
			this.extractEntry(destDir, entry);
		}
	}
	/**
	 * Extract an entry from the archive. This method assumes that the tarIn stream has been properly set with a call to getNextEntry().
	 * @param destDir      The destination directory into which to extract.
	 * @param entry        The TarEntry returned by tarIn.getNextEntry().
	 */
	private void extractEntry(File destDir, TarEntry entry) throws IOException {
		if (this.verbose) {
			/*//TODO
			if (this.progressDisplay != null)
				this.progressDisplay.showTarProgressMessage(entry.getName());
			*/
		}
		String name = entry.getName();
		name = name.replace('/', File.separatorChar);
		File destFile = new File(destDir, name);
		if (entry.isDirectory()) {
			if (!destFile.exists()&&!destFile.mkdirs()) {
					throw new IOException("error making directory path '"+ destFile.getPath() + "'");
			}
		} else {
			File subDir = new File(destFile.getParent());
			if (!subDir.exists()&& !subDir.mkdirs()) {
					throw new IOException("error making directory path '"+ subDir.getPath() + "'");
			}
			if (this.keepOldFiles && destFile.exists()) {
				if (this.verbose) {
					/*//TODO
					if (this.progressDisplay != null)
						this.progressDisplay.showTarProgressMessage("not overwriting "+ entry.getName());
					*/
				}
			} else {
				boolean asciiTrans = false;
				FileOutputStream out = new FileOutputStream(destFile);
				if (this.asciiTranslate) {
					code2code1(asciiTrans, destFile,"EXTRACT");
				}
				PrintWriter outw = null;
				if (asciiTrans) {
					outw = new PrintWriter(out);
				}
				byte[] rdbuf = new byte[32 * 1024];
				for (;;) {
					int numRead = this.tarIn.read(rdbuf);
					if (numRead == -1)
						break;
					if (asciiTrans) {
						for (int off = 0, b = 0; b < numRead; ++b) {
							if (rdbuf[b] == 10) {
								String s = new String(rdbuf, off, (b - off));
								outw.println(s);
								off = b + 1;
							}
						}
					} else {
						out.write(rdbuf, 0, numRead);
					}
				}
				if (asciiTrans)
					outw.close();
				else
					out.close();
			}
		}
	}
	private void code2code1 (boolean asciiTrans,File file,String errmsg){
		MimeType mime = null;
		String contentType = null;
		try {
			contentType = FileTypeMap.getDefaultFileTypeMap().getContentType(file);
			mime = new MimeType(contentType);
			if (mime.getPrimaryType().equalsIgnoreCase("text")){
				asciiTrans = true;
			}
		} catch (MimeTypeParseException ex) {
			// IGNORE THIS ERROR...
		}
		if (DEBUG) {
			System.err.println(errmsg+ " TRANS? '"+asciiTrans+"'  ContentType='"+contentType+"'  PrimaryType='"+mime.getPrimaryType()+"'");
		}
	}
	/**
	 * Write an entry to the archive. This method will call the putNextEntry() and then write the contents of the entry, and finally call closeEntry()
	 * for entries that are files. For directories, it will call putNextEntry(), and then, if the recurse flag is true, process each entry that is a child
	 * of the directory.
	 * @param entry         The TarEntry representing the entry to write to the archive.
	 * @param recurse       If true, process the children of directory entries.
	 */
	public void writeEntry(TarEntry oldEntry, boolean recurse)throws IOException {
		boolean asciiTrans = false;
		boolean unixArchiveFormat = oldEntry.isUnixTarFormat();
		File tFile = null;
		File eFile = oldEntry.getFile();
		// Work on a copy of the entry so we can manipulate it.
		// Note that we must distinguish how the entry was constructed.
		TarEntry entry = (TarEntry) oldEntry.clone();
/*//TODO
		if (this.verbose) {
			if (this.progressDisplay != null)
				this.progressDisplay.showTarProgressMessage(entry.getName());
		}
*/
		if (this.asciiTranslate && !entry.isDirectory()) {
			code2code1(asciiTrans ,eFile,"CREATE");
			if (asciiTrans) {
				String tempFileName = this.getTempFilePath(eFile);
				tFile = new File(tempFileName);
				BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(eFile)));
				BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(tFile));
				for (;;) {
					String line = in.readLine();
					if (line == null)
						break;
					out.write(line.getBytes());
					out.write((byte) '\n');
				}
				in.close();
				out.flush();
				out.close();
				entry.setSize(tFile.length());
				eFile = tFile;
			}
		}
		String newName = null;
		if (this.rootPath != null && entry.getName().startsWith(this.rootPath)) {
				newName = entry.getName().substring(this.rootPath.length() + 1);
		}
		if (this.pathPrefix != null) {
			newName = (newName == null) ? this.pathPrefix + "/"	+ entry.getName() : this.pathPrefix + "/" + newName;
		}
		if (newName != null) {
			entry.setName(newName);
		}
		this.tarOut.putNextEntry(entry);
		if(entry.isDirectory()){
			if (recurse) {
				TarEntry[] list = entry.getDirectoryEntries();
				for (int i = 0; i < list.length; ++i) {
					TarEntry dirEntry = list[i];
					if (unixArchiveFormat)
						dirEntry.setUnixTarFormat();
					this.writeEntry(dirEntry, recurse);
				}
			}
		}else{
			FileInputStream in = new FileInputStream(eFile);
			byte[] eBuf = new byte[32 * 1024];
			for (;;){
				int numRead = in.read(eBuf, 0, eBuf.length);
				if (numRead == -1)
					break;
				this.tarOut.write(eBuf, 0, numRead);
			}
			in.close();
			if (tFile != null) {
				tFile.delete();
			}
			this.tarOut.closeEntry();
		}
	}
}// 817  no crimalcode Tuned by Lieven

